package com.qf.config;

import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 声明交换机和队列，以及交换机和队列的绑定关系
 */
@Configuration
public class RabbitmqConfig {

    /**
     *  声明一个topic类型的交换机
     * @return
     */
    @Bean
    public Exchange topicEx(){
        return ExchangeBuilder
                .topicExchange("boot.topicEx")
                .durable(true) //设置交换机持久化
//                .alternate("交换机名称")  //当消息到达boot.topicEx后，但是路由失败了，消息会转到alternate指定的交换机上
                .build();
    }

    /**
     * 声明一个持久化的队列
     * @return
     */
    @Bean
    public Queue queue1(){
       return QueueBuilder.durable("boot.topicQue1").build();
    }

    /**
     * 声明一个持久化的队列
     * @return
     */
    @Bean
    public Queue queue2(){
        return QueueBuilder.durable("boot.topicQue2").build();
    }

    /**
     * 绑定queue1和topicEx的关系，使用的路由键是 A.*
     * @param queue1
     * @param topicEx
     * @return
     */
    @Bean
    public Binding binding1(Queue queue1,Exchange topicEx){
        return BindingBuilder.bind(queue1).to(topicEx).with("A.*").noargs();
    }

    /**
     * 绑定queue1和topicEx的关系，使用的路由键是 A.*
     * @param queue2
     * @param topicEx
     * @return
     */
    @Bean
    public Binding binding2(Queue queue2,Exchange topicEx){
        return BindingBuilder.bind(queue2).to(topicEx).with("A.#").noargs();
    }

    /**============================死信交换机=============================*/
    /**
     * 声明一个可以产生死信消息的队列
     */
    @Bean
    public Queue proDeadMsgQue(){
        return QueueBuilder
                .durable("boot.proDeadMsgQue")
                //指定死信交换机名称
                .deadLetterExchange("boot.dlEx")
                //指定消息向死信交换机发送时，路由键的名称
                .deadLetterRoutingKey("boot.dlKey")
                //指定当前队列的最大容纳消息的长度
                .maxLength(5)
                //指定当前队列中消息的超时时间
                .ttl(10000)
                .build();
    }

    //绑定产生死信消息的队列和普通交换机的关系
    @Bean
    public Binding binding3(Queue proDeadMsgQue,Exchange topicEx){
        return BindingBuilder.bind(proDeadMsgQue).to(topicEx).with("dl.#").noargs();
    }

    /**
     * 声明一个死信交换机
     */
    @Bean
    public Exchange dlEx(){
        return ExchangeBuilder.directExchange("boot.dlEx").durable(true).build();
    }

    /**
     * 声明一个死信队列
     * @return
     */
    @Bean
    public Queue dlQue(){
        return QueueBuilder.durable("dlQue").build();
    }

    /**
     * 绑定死信队列和死信交换机的关系
     */
    @Bean
    public  Binding binding4(Queue dlQue,Exchange dlEx){
        return BindingBuilder.bind(dlQue).to(dlEx).with("boot.dlKey").noargs();
    }

    /**
     * 创建一个惰性队列
     */
    @Bean
    public Queue lazyQue(){
        return QueueBuilder
                .durable("lazyQue")
                .lazy() //设置该队列为惰性队列
                .build();
    }

    /**
     * 绑定惰性队列和交换机的关系
     */
    @Bean
    public Binding binding5(Queue lazyQue,Exchange topicEx){
        return BindingBuilder.bind(lazyQue).to(topicEx).with("lazy.#").noargs();
    }
}
